package cn.shopping.core.daomanager.immutable;

import cn.shopping.common.daomanager.CommonDaoManager;
import cn.shopping.core.dbo.UploadInfoImgDO;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;


/**
 * 代码自动生成，请不要修改，切记！！！
 */
public interface ImmutableUploadInfoImgDaoManager extends CommonDaoManager<UploadInfoImgDO,Long> {


        public List<UploadInfoImgDO> listByUploadId(Long uploadId, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByUploadId(Long uploadId, String... fieldNames);

        public Integer countByUploadId(Long uploadId);

        public default UploadInfoImgDO singleResultByUploadId(Long uploadId,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUploadId(uploadId,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByUploadId(Long uploadId, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUploadId(uploadId,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUploadId(UploadInfoImgDO updateDO, Long uploadId);

        public Integer updateAllFieldsByUploadId(UploadInfoImgDO updateDO,  Long uploadId);

        public Integer deleteByUploadId( Long uploadId);






        public List<UploadInfoImgDO> listByInUploadId(Collection<Long> uploadIdList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInUploadId(Collection<Long> uploadIdList, String... fieldNames);

         public Integer countByInUploadId(Collection<Long> uploadIdList);

         public default UploadInfoImgDO singleResultByInUploadId(Collection<Long> uploadIdList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUploadId(uploadIdList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInUploadId(Collection<Long> uploadIdList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUploadId(uploadIdList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUploadId(UploadInfoImgDO updateDO, Collection<Long> uploadIdList);

         public Integer updateAllFieldsByInUploadId(UploadInfoImgDO updateDO,  Collection<Long> uploadIdList);

         public Integer deleteByInUploadId( Collection<Long> uploadIdList);
        public List<UploadInfoImgDO> listByFilePath(String filePath, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByFilePath(String filePath, String... fieldNames);

        public Integer countByFilePath(String filePath);

        public default UploadInfoImgDO singleResultByFilePath(String filePath,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFilePath(filePath,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByFilePath(String filePath, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFilePath(filePath,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFilePath(UploadInfoImgDO updateDO, String filePath);

        public Integer updateAllFieldsByFilePath(UploadInfoImgDO updateDO,  String filePath);

        public Integer deleteByFilePath( String filePath);






        public List<UploadInfoImgDO> listByInFilePath(Collection<String> filePathList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInFilePath(Collection<String> filePathList, String... fieldNames);

         public Integer countByInFilePath(Collection<String> filePathList);

         public default UploadInfoImgDO singleResultByInFilePath(Collection<String> filePathList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFilePath(filePathList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInFilePath(Collection<String> filePathList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFilePath(filePathList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFilePath(UploadInfoImgDO updateDO, Collection<String> filePathList);

         public Integer updateAllFieldsByInFilePath(UploadInfoImgDO updateDO,  Collection<String> filePathList);

         public Integer deleteByInFilePath( Collection<String> filePathList);
        public List<UploadInfoImgDO> listByFileSize(Long fileSize, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByFileSize(Long fileSize, String... fieldNames);

        public Integer countByFileSize(Long fileSize);

        public default UploadInfoImgDO singleResultByFileSize(Long fileSize,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFileSize(fileSize,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByFileSize(Long fileSize, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFileSize(fileSize,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileSize(UploadInfoImgDO updateDO, Long fileSize);

        public Integer updateAllFieldsByFileSize(UploadInfoImgDO updateDO,  Long fileSize);

        public Integer deleteByFileSize( Long fileSize);






        public List<UploadInfoImgDO> listByInFileSize(Collection<Long> fileSizeList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInFileSize(Collection<Long> fileSizeList, String... fieldNames);

         public Integer countByInFileSize(Collection<Long> fileSizeList);

         public default UploadInfoImgDO singleResultByInFileSize(Collection<Long> fileSizeList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFileSize(fileSizeList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInFileSize(Collection<Long> fileSizeList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFileSize(fileSizeList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFileSize(UploadInfoImgDO updateDO, Collection<Long> fileSizeList);

         public Integer updateAllFieldsByInFileSize(UploadInfoImgDO updateDO,  Collection<Long> fileSizeList);

         public Integer deleteByInFileSize( Collection<Long> fileSizeList);
        public List<UploadInfoImgDO> listByFilePixel(Integer filePixel, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByFilePixel(Integer filePixel, String... fieldNames);

        public Integer countByFilePixel(Integer filePixel);

        public default UploadInfoImgDO singleResultByFilePixel(Integer filePixel,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFilePixel(filePixel,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByFilePixel(Integer filePixel, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByFilePixel(filePixel,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFilePixel(UploadInfoImgDO updateDO, Integer filePixel);

        public Integer updateAllFieldsByFilePixel(UploadInfoImgDO updateDO,  Integer filePixel);

        public Integer deleteByFilePixel( Integer filePixel);






        public List<UploadInfoImgDO> listByInFilePixel(Collection<Integer> filePixelList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInFilePixel(Collection<Integer> filePixelList, String... fieldNames);

         public Integer countByInFilePixel(Collection<Integer> filePixelList);

         public default UploadInfoImgDO singleResultByInFilePixel(Collection<Integer> filePixelList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFilePixel(filePixelList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInFilePixel(Collection<Integer> filePixelList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInFilePixel(filePixelList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFilePixel(UploadInfoImgDO updateDO, Collection<Integer> filePixelList);

         public Integer updateAllFieldsByInFilePixel(UploadInfoImgDO updateDO,  Collection<Integer> filePixelList);

         public Integer deleteByInFilePixel( Collection<Integer> filePixelList);
        public List<UploadInfoImgDO> listByUserIdCreate(Long userIdCreate, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByUserIdCreate(Long userIdCreate, String... fieldNames);

        public Integer countByUserIdCreate(Long userIdCreate);

        public default UploadInfoImgDO singleResultByUserIdCreate(Long userIdCreate,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByUserIdCreate(Long userIdCreate, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdCreate(UploadInfoImgDO updateDO, Long userIdCreate);

        public Integer updateAllFieldsByUserIdCreate(UploadInfoImgDO updateDO,  Long userIdCreate);

        public Integer deleteByUserIdCreate( Long userIdCreate);






        public List<UploadInfoImgDO> listByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames);

         public Integer countByInUserIdCreate(Collection<Long> userIdCreateList);

         public default UploadInfoImgDO singleResultByInUserIdCreate(Collection<Long> userIdCreateList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInUserIdCreate(Collection<Long> userIdCreateList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUserIdCreate(UploadInfoImgDO updateDO, Collection<Long> userIdCreateList);

         public Integer updateAllFieldsByInUserIdCreate(UploadInfoImgDO updateDO,  Collection<Long> userIdCreateList);

         public Integer deleteByInUserIdCreate( Collection<Long> userIdCreateList);
        public List<UploadInfoImgDO> listByUserIdModified(Long userIdModified, String... fieldNames);

        public Map<Long,UploadInfoImgDO> mapByUserIdModified(Long userIdModified, String... fieldNames);

        public Integer countByUserIdModified(Long userIdModified);

        public default UploadInfoImgDO singleResultByUserIdModified(Long userIdModified,String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoImgDO>> groupingByUserIdModified(Long userIdModified, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
             List<UploadInfoImgDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdModified(UploadInfoImgDO updateDO, Long userIdModified);

        public Integer updateAllFieldsByUserIdModified(UploadInfoImgDO updateDO,  Long userIdModified);

        public Integer deleteByUserIdModified( Long userIdModified);






        public List<UploadInfoImgDO> listByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames);

         public Map<Long,UploadInfoImgDO> mapByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames);

         public Integer countByInUserIdModified(Collection<Long> userIdModifiedList);

         public default UploadInfoImgDO singleResultByInUserIdModified(Collection<Long> userIdModifiedList,String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoImgDO>> groupingByInUserIdModified(Collection<Long> userIdModifiedList, Function<UploadInfoImgDO, T> mapper, String... fieldNames){
              List<UploadInfoImgDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUserIdModified(UploadInfoImgDO updateDO, Collection<Long> userIdModifiedList);

         public Integer updateAllFieldsByInUserIdModified(UploadInfoImgDO updateDO,  Collection<Long> userIdModifiedList);

         public Integer deleteByInUserIdModified( Collection<Long> userIdModifiedList);


}

